home *** CD-ROM | disk | FTP | other *** search
/ DOpus Plus / DOpus Plus.iso / Tutorial / C Guide / Simple_Module2 / IPCWindow / IPCWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-09-01  |  11.3 KB  |  306 lines
  1. /*******************************************************************
  2.  
  3.    IPCWindow.c
  4.     
  5.     Does open a simple window with some easy gadgets, does create a
  6.     new process, is protected to launch not twice and does show all
  7.     arguments even if they are given with a new command.
  8.                     
  9. *********************************************************************/
  10.  
  11. #define PARENT
  12. #include "/includes/Window.h"
  13.  
  14. typedef struct _PassingData
  15. {
  16.         ULONG a4;                 // to store a4 (module is a4 relative)
  17.         struct Library *library;  // to store a pointer to dopus5.library 
  18.         struct Library *module;   // to store a pointer to this module
  19.         IPCData *ipc;             // to store our NEW handle
  20.              
  21.         struct Screen *screen;
  22. }  PassingData;   
  23.  
  24. /********************************************************************/
  25. // locale prototypes and variables
  26.  
  27. ULONG __asm __saveds New_Proc_Startup( register __a0 IPCData *ipc,
  28.                                        register __a1 PassingData *pd );
  29.                                                                                                         
  30. void __saveds New_Proc( void ); 
  31.  
  32. BOOL OpenDOpusWin( WindowHandle *wh ); // the same old function
  33.  
  34. BOOL HandleWindow( WindowHandle *wh ); // the same old function
  35.  
  36.  
  37. extern IPCData *proc_ipc;
  38. // declared in modinit.c, because must be initialized to NULL on startup 
  39.  
  40. /********************************************************************/
  41. // this is the same function like in DetachWindow.
  42. // it is the first special function we need...
  43.  
  44. void OwnWindow( STRPTR args, struct Screen *screen )
  45. {
  46.     PassingData *pd;
  47.         
  48.    if( (pd = AllocMemH(mempool, sizeof(PassingData))) ) // allocate some memory
  49.      {
  50.           pd->screen = screen;          // store the screen pointer
  51.                 
  52.           if( !proc_ipc ) // only if the process is not already running
  53.             {
  54.                  // now some special stuff, but everything is needed here...
  55.              pd->a4      = getreg( REG_A4 ); 
  56.              pd->module  = (struct Library *) getreg( REG_A6 );
  57.              pd->library = DOpusBase;
  58.                   
  59.              // now we are ready to call IPC_Launch()
  60.              IPC_Launch( 0, 
  61.                          &proc_ipc,         // pointer to pointer to the IPC of the new process, for storing...
  62.                          "ExampleWindow",  // name of the new process
  63.                          (ULONG) New_Proc, // entrypoint of the new process
  64.                          4096,             // stack to use
  65.                          (ULONG) pd,       // data to pass to the new process
  66.                          DOSBase );        // pointer to dos.library
  67.                                  
  68.                  
  69.                                                   
  70.              if( !proc_ipc )              // if detaching failed...
  71.                    {
  72.                         FreeMemH( pd );
  73.                       return;
  74.                     }
  75.                     
  76.                  Delay( 10 ); // give a small time for startup...
  77.                               // not really needed
  78.              }
  79.              
  80.           // now should our process running
  81.           // since we use in the process not the arguments on startup to save
  82.           // some work, we have to pass it now.
  83.           
  84.           IPC_Command( proc_ipc,  // "address" (IPCData) of receiver
  85.                        NULL,      // we use no commands here
  86.                             NULL,      // also no flags
  87.                             args,      // our data to pass to the new process
  88.                             NULL,      // no other data (will be FreeVec'd)
  89.                             REPLY_NO_PORT ); // use normal DOpus IPC_Reply() later
  90.                             
  91.          FreeMemH( pd );
  92.       }
  93.           // ready... :)
  94. }
  95.  
  96. // let's do now the second special function
  97.  
  98. ULONG __asm __saveds New_Proc_Startup( register __a0 IPCData *ipc,
  99.                                        register __a1 PassingData *pd )
  100. {
  101.         // you may use this function also to setup things for your
  102.         // main process, but you should not call any IPC functions here !
  103.         // we do only the minimum required..., but you will get some small
  104.         // warnings from your compiler. Just ignore them now - they does
  105.         // not appear, if we would do here some more things... 
  106.         
  107.         struct Library *DOpusBase; 
  108.  
  109.         // fix A4
  110.         putreg( REG_A4, pd->a4 );
  111.  
  112.         // store IPC pointer
  113.         pd->ipc = ipc;
  114.  
  115.         // get dopus.library - one warning now
  116.         DOpusBase = pd->library;
  117.  
  118.         // now may follow your initialization
  119.         
  120.         // if something fails and you must quit, you should do:
  121.         // return FALSE;
  122.  
  123.         // increase our library counter, so we can not be flushed
  124.         // do not forget to decrease it, if your detached process ends 
  125.         pd->module->lib_OpenCnt++;
  126.         
  127.         return TRUE; // all was successfully
  128. } 
  129.  
  130. void __saveds New_Proc( void )
  131. {
  132.         // this is now just the same like until now our OwnWindow() function
  133.         
  134.         WindowHandle          *wh;
  135.         PassingData           *pd;
  136.           IPCData               *ipc;
  137.           IPCMessage            *ipcmsg;
  138.         struct Library        *DOpusBase;
  139.           struct Library        *module;
  140.         
  141.         // but we must do some additional things 
  142.         
  143.         // get dopus library
  144.         if( !(DOpusBase = (struct Library *) FindName(&((struct ExecBase *)*((ULONG *)4))->LibList, "dopus5.library")) )
  145.                 return;
  146.         
  147.         // do startup 
  148.         ipc = IPC_ProcStartup( (ULONG *) &pd, New_Proc_Startup );
  149.  
  150.         // fix A4 so we can access global data in the module (eg library bases)
  151.         putreg( REG_A4, pd->a4 );
  152.         
  153.           // we must store this pointer too 
  154.           module = pd->module;
  155.           
  156.         // something failed until now ?
  157.         if( !ipc )
  158.           {
  159.                  if( pd )
  160.                {
  161.                         IPC_Free( pd->ipc ); // possible it has a value here 
  162.                   FreeMemH( pd );      // free our memory
  163.                }
  164.                           
  165.              return;
  166.           }
  167.                 
  168.         if( (wh = AllocMemH(mempool, sizeof(WindowHandle))) ) // allocate some memory
  169.           {
  170.              if( OpenDOpusWin(wh) )   // open the window
  171.                {
  172.                         // before we have set on this place the value of our
  173.                         // textgadget, but now we have not the arguments. So
  174.                         // we wait to set the value until the command arrives. 
  175.                         
  176.                         while( TRUE ) 
  177.                     {
  178.                               // I use here Wait(), so it is easier with the changes
  179.                                  
  180.                        wh->signals = Wait( 1 << proc_ipc->command_port->mp_SigBit | // wait for IPC messages
  181.                                                   1 << wh->win->UserPort->mp_SigBit );   // wait for window events
  182.                                                                                                 
  183.                        if( wh->signals & 1 << wh->win->UserPort->mp_SigBit )
  184.                             if( HandleWindow(wh) )
  185.                                  break;           // does end the while loop
  186.                               
  187.                               if( wh->signals & 1 << proc_ipc->command_port->mp_SigBit ) // if we have got an IPC message
  188.                                 {
  189.                                      while( (ipcmsg = (IPCMessage *) GetMsg(proc_ipc->command_port)) )
  190.                                        {
  191.                                             
  192.                                             // we copy now the arguments into the text gadget
  193.                                  // if we have supplied some..., else it will be cleared
  194.                                             // I do not cut here the last signs...
  195.                                  
  196.                                  SetGadgetValue( wh->olist, GADGET_ID_TEXT, (ULONG) ipcmsg->data );
  197.                                             
  198.                                             IPC_Reply( ipcmsg ); // do not use ReplyMsg() or something else !
  199.                                         }
  200.                          }                
  201.                     }
  202.                           
  203.                   CloseConfigWindow( wh->win ); 
  204.                 }
  205.                          
  206.               FreeMemH( wh ); // free our memory
  207.           }
  208.              
  209.           // decrease our Library access counter, since we have increased it before
  210.         --module->lib_OpenCnt;   
  211.                             
  212.         // since we are here a detached process, we must do some other cleanup too
  213.         IPC_Free( proc_ipc );
  214.           
  215.           proc_ipc = NULL;    // do not forget this...                                                     
  216. } 
  217.  
  218. /********************************************************************/
  219. // This function does open our window. We could have done this in the
  220. // function OwnWindow() too, but we need this function later again.
  221.  
  222. BOOL OpenDOpusWin( WindowHandle *wh )
  223. {
  224.     NewConfigWindow ncfgwin;     // we need a NewConfigWindow structure too
  225.                                  // of couse you could also allocate it with
  226.                                           // AllocMemH()...
  227.     
  228.     // and have to fill it
  229.     
  230.     ncfgwin.nw_Parent = wh->screen;  // open on this screen
  231.     
  232.     // getting a localized title...
  233.     ncfgwin.nw_Title  = DOpusGetString( locale, MSG_WINDOW_TITLE );
  234.     
  235.     ncfgwin.nw_Dims   = &cfgwin; // a pointer to the ConfigWin structure
  236.     ncfgwin.nw_Locale = locale;  // the module locale pointer (from modinit.c)
  237.     ncfgwin.nw_Port   = NULL;    // we doesn't supply a port
  238.     ncfgwin.nw_Font   = NULL;    // just taking the screen font
  239.     ncfgwin.nw_Flags  = WINDOW_REQ_FILL      | // fill with stripple pattern
  240.                         WINDOW_AUTO_KEYS     | // handle keys automatic
  241.                               WINDOW_SCREEN_PARENT;  // nw_Parent points to a screen
  242.     
  243.     if( (wh->win = OpenConfigWindow(&ncfgwin)) )   // open the window
  244.       {
  245.           if( (wh->olist = AddObjectList(wh->win, odef)) ) // add the gadgets
  246.                   return TRUE;
  247.                     
  248.           CloseConfigWindow( wh->win );    //    in error case do not forget :-)
  249.       }
  250.     
  251.     return FALSE;
  252. }
  253.  
  254.  
  255. /********************************************************************/
  256. // we does only close the window, if the closegadget was pressed
  257. // if you want to close it within a gadget, you must only in the
  258. // right case set "stop" to TRUE
  259.  
  260. BOOL HandleWindow( WindowHandle *wh )
  261. {
  262.      BOOL stop = FALSE;
  263.      ULONG value;
  264.      
  265.      while( !stop && (wh->imsg = GetWindowMsg(wh->win->UserPort)) )
  266.         {
  267.             switch( wh->imsg->Class )  // let's handle the IDCMP
  268.               {
  269.                   case IDCMP_GADGETUP:
  270.                                           switch( GET_ID(wh->imsg) )
  271.                                          {
  272.                                                          case GADGET_ID_CYCLE:  // we copy simply the same text to the text gadget
  273.             
  274.                                                                      value = GetGadgetValue( wh->olist, GADGET_ID_CYCLE ) + MSG_CLICK_ME;
  275.                                                                             SetGadgetValue( wh->olist, GADGET_ID_TEXT, (ULONG) DOpusGetString(locale, value) );
  276.                                                                             break;
  277.             
  278.                                               case GADGET_ID_OKAY:   // doing a message
  279.                                                                      
  280.                                                                                         SetGadgetValue( wh->olist, GADGET_ID_TEXT, (ULONG) DOpusGetString(locale, MSG_OKAY_DONE) );
  281.                                                                             break;
  282.                                                      
  283.                                               case GADGET_ID_CANCEL: 
  284.                                                                      SetGadgetValue( wh->olist, GADGET_ID_TEXT, (ULONG) DOpusGetString(locale, MSG_CANCEL_DONE) );
  285.                                                                             break;
  286.                                           }
  287.                                                                  
  288.                                                   break;
  289.                                      
  290.                   case IDCMP_CLOSEWINDOW:
  291.                                           // we can not simply return here, the IntuiMessage must replied first
  292.                                                   
  293.                                                stop = TRUE;
  294.                                                   break;                                     
  295.               }
  296.                                  
  297.             ReplyWindowMsg( wh->imsg );  
  298.                               
  299.             // remember: You should not use any other routines
  300.             // to get/reply the messages of this window than
  301.             // GetWindowMsg() and ReplyWindowMsg() !!
  302.        }
  303.                                
  304.     return stop;
  305. }
  306.